C:/Projekte/RAIS/dataaccesslayertest/UserManagementTest.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Text;
using System.Xml;
using NUnit.Framework;
using RAIS.Common.UserManagement;
using RAIS.DataAccessLayer;

using UserTypes = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.UserTypeData>;
using Users = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.UserData>;
using FunctionRoles = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.FunctionRole>;
using DataRoles = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.DataRole>;
using FunctionRoleCategories = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.FunctionRole.Category>;
using FunctionRoleSubcategories = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.FunctionRole.Subcategory>;
using Masks = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.Mask>;
using Regions = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.Region>;
using Districts = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.District>;
using Facilities = System.Collections.Generic.Dictionary<string, RAIS.Common.UserManagement.Facility>;

namespace RAIS.DataAccessLayerTest
{
        [TestFixture]
        public class UserManagementTest
        {
                #region Properties
                [Test]
                public void UserTypeAdminstrator()
                {
                        // Preparations
                        /*UserData.UserType expectedType = UserData.UserType.Admin;
                        int expectedID = 1;
                        string expectedVisibleName = "Administrator";

                        // Test
                        UserTypes userTypes = UserManagement.UserTypes;

                        // Checks
                        Assert.AreEqual(expectedID, userTypes[expectedVisibleName].ID);
                        Assert.AreEqual(expectedType, userTypes[expectedVisibleName].Type);
                        Assert.AreEqual(expectedVisibleName, userTypes[expectedVisibleName].VisibleName);*/
                }
                [Test]
                public void UserTypeRegulator()
                {
                        // Preparations
                        UserData.UserType expectedType = UserData.UserType.Regulator;
                        int expectedID = 2;
                        string expectedVisibleName = "Regulator";

                        // Test
                        UserTypes userTypes = UserManagement.UserTypes;

                        // Checks
                        Assert.AreEqual(expectedID, userTypes[expectedVisibleName].ID);
                        Assert.AreEqual(expectedType, userTypes[expectedVisibleName].Type);
                        Assert.AreEqual(expectedVisibleName, userTypes[expectedVisibleName].VisibleName);
                }
                [Test]
                public void UserTypeLicensee()
                {
                        // Preparations
                        UserData.UserType expectedType = UserData.UserType.Licensee;
                        int expectedID = 3;
                        string expectedVisibleName = "Licensee";

                        // Test
                        UserTypes userTypes = UserManagement.UserTypes;

                        // Checks
                        Assert.AreEqual(expectedID, userTypes[expectedVisibleName].ID);
                        Assert.AreEqual(expectedType, userTypes[expectedVisibleName].Type);
                        Assert.AreEqual(expectedVisibleName, userTypes[expectedVisibleName].VisibleName);
                }
                /*[Test]
                public void UserTypePublicBody()
                {
                        // Preparations
                        UserData.UserType expectedType = UserData.UserType.PublicBody;
                        int expectedID = 4;
                        string expectedVisibleName = "Public Body";

                        // Test
                        UserTypes userTypes = UserManagement.UserTypes;

                        // Checks
                        Assert.AreEqual(expectedID, userTypes[expectedVisibleName].ID);
                        Assert.AreEqual(expectedType, userTypes[expectedVisibleName].Type);
                        Assert.AreEqual(expectedVisibleName, userTypes[expectedVisibleName].VisibleName);
                }*/
                [Test]
                public void UserTypeGuest()
                {
                        // Preparations
                        UserData.UserType expectedType = UserData.UserType.Guest;
                        int expectedID = 5;
                        string expectedVisibleName = "Guest";

                        // Test
                        UserTypes userTypes = UserManagement.UserTypes;

                        // Checks
                        Assert.AreEqual(expectedID, userTypes[expectedVisibleName].ID);
                        Assert.AreEqual(expectedType, userTypes[expectedVisibleName].Type);
                        Assert.AreEqual(expectedVisibleName, userTypes[expectedVisibleName].VisibleName);
                }
                [Test]
                public void Users()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        int expectedCount = 3;

                        UserData[] expectedUsers = new UserData[expectedCount];
                        for (int i = 0; i < expectedCount; i++)
                                expectedUsers[i] = TestUtilities.NewTestUserWithSave(i);

                        // Test
                        Users checkUsers = UserManagement.Users;

                        // Checks
                        Assert.AreEqual(expectedCount, checkUsers.Count, "Wrong Users count:");

                        for (int i = 0; i < expectedCount; i++)
                                Assert.AreEqual(expectedUsers[i].Name, checkUsers[expectedUsers[i].Login].Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void FunctionRoles()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        int expectedCount = 3;

                        FunctionRole[] expectedFunctionRoles = new FunctionRole[expectedCount];
                        for (int i = 0; i < expectedCount; i++ )
                                expectedFunctionRoles[i] = TestUtilities.NewTestFunctionRoleWithSave(i);

                        // Test
                        FunctionRoles checkFunctionRoles = UserManagement.FunctionalRoles;

                        // Checks
                        Assert.AreEqual(expectedCount, checkFunctionRoles.Count, "Wrong FunctionRoles count:");

                        for (int i = 0; i < expectedCount; i++)
                                Assert.AreEqual(expectedFunctionRoles[i].Name, checkFunctionRoles[expectedFunctionRoles[i].Name].Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void FunctionRoleCategories()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        int expectedCount = 4;

                        FunctionRole.Category[] expectedCategories = new FunctionRole.Category[expectedCount];
                        for (int i = 0; i < expectedCount - 1; i++)
                                expectedCategories[i] = TestUtilities.NewTestCategoryWithSave(i);

                        // Test
                        FunctionRoleCategories checkCategories = UserManagement.FunctionalRoleCategories;

                        // Checks
                        Assert.AreEqual(expectedCount, checkCategories.Count, "Wrong Categories count:");

                        for (int i = 0; i < expectedCount - 1; i++)
                                Assert.AreEqual(expectedCategories[i].Name, checkCategories[expectedCategories[i].Name].Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void DataRoles()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        int expectedCount = 3;

                        DataRole[] expectedDataRoles = new DataRole[expectedCount];
                        for (int i = 0; i < expectedCount; i++)
                                expectedDataRoles[i] = TestUtilities.NewTestDataRoleWithSave(i);

                        // Test
                        DataRoles checkDataRoles = UserManagement.DataRoles;

                        // Checks
                        Assert.AreEqual(expectedCount, checkDataRoles.Count, "Wrong DataRoles count:");

                        for (int i = 0; i < expectedCount; i++)
                                Assert.AreEqual(expectedDataRoles[i].Name, checkDataRoles[expectedDataRoles[i].Name].Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void Regions()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        int expectedCount = 3;

                        Region[] expectedRegions = new Region[expectedCount];
                        for (int i = 0; i < expectedCount - 1; i++)
                                expectedRegions[i] = TestUtilities.NewTestRegionWithSave(i);

                        // Test
                        Regions checkRegions = UserManagement.Regions;

                        // Checks
                        Assert.AreEqual(expectedCount, checkRegions.Count, "Wrong Regions count:");

                        for (int i = 0; i < expectedCount - 1; i++)
                                Assert.AreEqual(expectedRegions[i].Name, checkRegions[expectedRegions[i].Name].Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void Facilities()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        int expectedCount = 4;

                        Facility[] expectedFacilities = new Facility[expectedCount];
                        for (int i = 0; i < expectedCount - 1; i++)
                        {
                                Region region = TestUtilities.NewTestRegionWithSave(i);
                                District district = TestUtilities.NewTestDistrictWithSave(i, region);
                                expectedFacilities[i] = TestUtilities.NewTestFacilityWithSave(i, region, district);
                        }

                        // Test
                        Facilities checkFacilities = UserManagement.Facilities;

                        // Checks
                        Assert.AreEqual(expectedCount, checkFacilities.Count, "Wrong Facilities count:");

                        for (int i = 0; i < expectedCount - 1; i++)
                                Assert.AreEqual(expectedFacilities[i].Name, checkFacilities[expectedFacilities[i].Name].Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                #endregion

                #region Public Methods
                [Test]
                public void GetUserData()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        UserData expectedUser = TestUtilities.NewTestUserWithSave(1);

                        // Test
                        UserData checkUser = UserManagement.GetUserData(expectedUser.Login);

                        // Checks
                        Assert.AreEqual(expectedUser.Name, checkUser.Name);
                        Assert.AreEqual(expectedUser.Login, checkUser.Login);
                        Assert.AreEqual(expectedUser.Password, checkUser.Password);
                        Assert.AreEqual(expectedUser.CompleteName, checkUser.CompleteName);
                        Assert.AreEqual(expectedUser.Email, checkUser.Email);
                        Assert.AreEqual(expectedUser.Locked, checkUser.Locked);
                        Assert.AreEqual(expectedUser.Type, checkUser.Type);
                        Assert.AreEqual(expectedUser.FunctionalRole.Name, checkUser.FunctionalRole.Name);
                        Assert.AreEqual(expectedUser.DataRole.Name, checkUser.DataRole.Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void UserExists()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;

                        UserData expectedUser = TestUtilities.NewTestUserWithSave(1);

                        // Test
                        returnStatus = UserManagement.UserExists(expectedUser.Login);

                        // Checks
                        Assert.IsTrue(returnStatus, "UserExists return code:");

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void AddUser()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";

                        UserData expectedUser = TestUtilities.NewTestUser(1);

                        // Test
                        returnStatus = UserManagement.AddUser(expectedUser, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus);

                        UserData checkUser = UserManagement.GetUserData(expectedUser.Login);
                        Assert.AreEqual(expectedUser.Name, checkUser.Name);
                        Assert.AreEqual(expectedUser.Login, checkUser.Login);
                        Assert.AreEqual(expectedUser.Password, checkUser.Password);
                        Assert.AreEqual(expectedUser.CompleteName, checkUser.CompleteName);
                        Assert.AreEqual(expectedUser.Email, checkUser.Email);
                        Assert.AreEqual(expectedUser.Locked, checkUser.Locked);
                        Assert.AreEqual(expectedUser.Type, checkUser.Type);
                        Assert.AreEqual(expectedUser.FunctionalRole.Name, checkUser.FunctionalRole.Name);
                        Assert.AreEqual(expectedUser.DataRole.Name, checkUser.DataRole.Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void ModifyUserName()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";
                        string expectedName = "Changed Test User Name";

                        UserData expectedUser = TestUtilities.NewTestUserWithSave(1);
                        expectedUser.Name = expectedName;

                        // Test
                        returnStatus = UserManagement.ModifyUser(expectedUser, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus);

                        UserData checkUser = UserManagement.GetUserData(expectedUser.Login);
                        Assert.AreEqual(expectedUser.Name, checkUser.Name);
                        Assert.AreEqual(checkUser.Name, checkUser.CompleteName);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void ModifyUserLogin()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";
                        string expectedLogin = "changedTestLogin";

                        UserData expectedUser = TestUtilities.NewTestUserWithSave(1);
                        expectedUser.Login = expectedLogin;

                        // Test
                        returnStatus = UserManagement.ModifyUser(expectedUser, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus);

                        UserData checkUser = UserManagement.GetUserData(expectedUser.Login);
                        Assert.AreEqual(expectedUser.Login, checkUser.Login);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void ModifyUserPassword()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";
                        string expectedPassword = "changedPassword";

                        UserData expectedUser = TestUtilities.NewTestUserWithSave(1);
                        expectedUser.Password = expectedPassword;

                        // Test
                        returnStatus = UserManagement.ModifyUser(expectedUser, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus);

                        UserData checkUser = UserManagement.GetUserData(expectedUser.Login);
                        Assert.AreEqual(expectedUser.Password, checkUser.Password);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void ModifyUserCompleteName()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";
                        string expectedCompleteName = "Changed Test User Complete Name";

                        UserData expectedUser = TestUtilities.NewTestUserWithSave(1);
                        expectedUser.CompleteName = expectedCompleteName;

                        // Test
                        returnStatus = UserManagement.ModifyUser(expectedUser, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus);

                        UserData checkUser = UserManagement.GetUserData(expectedUser.Login);
                        Assert.AreEqual(expectedUser.CompleteName, checkUser.CompleteName);
                        Assert.AreEqual(checkUser.Name, checkUser.CompleteName);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void ModifyUserEmail()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";
                        string expectedEmail = "changed@email.com";

                        UserData expectedUser = TestUtilities.NewTestUserWithSave(1);
                        expectedUser.Email = expectedEmail;

                        // Test
                        returnStatus = UserManagement.ModifyUser(expectedUser, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus);

                        UserData checkUser = UserManagement.GetUserData(expectedUser.Login);
                        Assert.AreEqual(expectedUser.Email, checkUser.Email);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                /*[Test]
                public void ModifyUserLocked()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";
                        bool expectedLocked = true;

                        UserData expectedUser = TestUtilities.NewTestUserWithSave(1);
                        expectedUser.Locked = expectedLocked;

                        // Test
                        returnStatus = UserManagement.ModifyUser(expectedUser, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus);

                        UserData checkUser = UserManagement.GetUserData(expectedUser.Login);
                        Assert.AreEqual(expectedUser.Locked, checkUser.Locked);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }*/
                [Test]
                public void ModifyUserType()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";
                        string expectedTypeText = "Licensee";

                        UserData expectedUser = TestUtilities.NewTestUserWithSave(1);
                        expectedUser.TypeText = expectedTypeText;

                        // Test
                        returnStatus = UserManagement.ModifyUser(expectedUser, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus);

                        UserData checkUser = UserManagement.GetUserData(expectedUser.Login);
                        Assert.AreEqual(expectedUser.TypeText, checkUser.TypeText);
                        Assert.AreEqual(expectedUser.Type, checkUser.Type);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void AddDataRole()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";

                        DataRole expectedDataRole = TestUtilities.NewDataRoleObject(1);

                        // Test
                        returnStatus = UserManagement.AddDataRole(expectedDataRole.Name, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus, "AddDataRole return status:");

                        DataRole checkDataRole = UserManagement.DataRoles[expectedDataRole.Name];
                        Assert.AreEqual(expectedDataRole.Name, checkDataRole.Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void AddDataRoleAttribute()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";

                        DataRole expectedDataRole = TestUtilities.NewTestDataRoleWithSave(1);
                        DataRoleAttribute expectsdDataRoleAttribute = TestUtilities.NewTestDataRoleAttribute(1);

                        // Test
                        returnStatus = UserManagement.AddDataRoleAttribute(expectedDataRole, expectsdDataRoleAttribute, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus, "AddDataRoleAttribute return status:");

                        DataRole checkDataRole = UserManagement.DataRoles[expectedDataRole.Name];
                        DataRoleAttribute checkDataRoleAttribute = checkDataRole.Attributes[expectsdDataRoleAttribute.ToString()];
                        Assert.AreEqual(1, checkDataRole.Attributes.Count);
                        Assert.AreEqual(expectsdDataRoleAttribute.Region.ID, checkDataRoleAttribute.Region.ID);
                        Assert.AreEqual(expectsdDataRoleAttribute.District.ID, checkDataRoleAttribute.District.ID);
                        Assert.AreEqual(expectsdDataRoleAttribute.Facility.ID, checkDataRoleAttribute.Facility.ID);
                        Assert.AreEqual(expectsdDataRoleAttribute.ToString(), checkDataRoleAttribute.ToString());

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                [ExpectedException(typeof(System.Collections.Generic.KeyNotFoundException))]
                public void RemoveDataRoleAttribute()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";

                        DataRole expectedDataRole = TestUtilities.NewTestDataRoleWithSave(1);
                        DataRoleAttribute expectsdDataRoleAttribute = TestUtilities.NewTestDataRoleAttribute(1);
                        returnStatus = UserManagement.AddDataRoleAttribute(expectedDataRole, expectsdDataRoleAttribute, ref errorMessage);
                        if (!returnStatus)
                                throw new Exception("Add Data Role Attribute Error");
                        DataRole checkDataRole = UserManagement.DataRoles[expectedDataRole.Name];
                        DataRoleAttribute checkDataRoleAttribute = checkDataRole.Attributes[expectsdDataRoleAttribute.ToString()];

                        // Test
                        returnStatus = UserManagement.RemoveDataRoleAttribute(checkDataRole, checkDataRoleAttribute, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus, "RemoveDataRoleAttribute return status:");

                        try
                        {
                                // Check that DataRoleAttribute does not exist in DataRoleAttributes dictionary
                                // Expected exception System.Collections.Generic.KeyNotFoundException
                                checkDataRole = UserManagement.DataRoles[expectedDataRole.Name];
                                checkDataRoleAttribute = checkDataRole.Attributes[expectsdDataRoleAttribute.ToString()];
                        }
                        finally
                        {
                                // Restore to previous state
                                Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                        }
                }
                [Test]
                [ExpectedException(typeof(System.Collections.Generic.KeyNotFoundException))]
                public void RemoveDataRole()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";

                        DataRole expectedDataRole = TestUtilities.NewTestDataRoleWithSave(1);

                        // Test
                        returnStatus = UserManagement.RemoveDataRole(expectedDataRole, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus, "RemoveDataRole return status:");

                        try
                        {
                                // Check that DataRole does not exist in DataRoles dictionary
                                // Expected exception System.Collections.Generic.KeyNotFoundException
                                DataRole checkDataRole = UserManagement.DataRoles[expectedDataRole.Name];
                                Assert.AreEqual(expectedDataRole.Name, checkDataRole.Name);
                        }
                        finally
                        {
                                // Restore to previous state
                                Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                        }
                }
                [Test]
                public void AddFunctionRole()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";

                        FunctionRole expectedFunctionRole = TestUtilities.NewFunctionRoleObject(1);

                        // Test
                        returnStatus = UserManagement.AddFunctionRole(expectedFunctionRole.Name, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus, "AddFunctionRole return status:");

                        FunctionRole checkFunctionRole = UserManagement.FunctionalRoles[expectedFunctionRole.Name];
                        Assert.AreEqual(expectedFunctionRole.Name, checkFunctionRole.Name);
                        Assert.AreEqual(expectedFunctionRole.Validation, checkFunctionRole.Validation);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void SaveFunctionRole()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";

                        FunctionRole expectedFunctionRole = TestUtilities.NewTestFunctionRoleWithSave(1);
                        expectedFunctionRole.Validation = FunctionRole.ValidationType.DoesNotNeedValidation;

                        // Test
                        returnStatus = UserManagement.SaveFunctionRole(expectedFunctionRole, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus, "RemoveFunctionRole return status:");

                        FunctionRole checkFunctionRole = UserManagement.FunctionalRoles[expectedFunctionRole.Name];
                        Assert.AreEqual(expectedFunctionRole.Validation, checkFunctionRole.Validation);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void AddFunctionRoleAttribute()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";

                        FunctionRole expectedFunctionRole = TestUtilities.NewTestFunctionRoleWithSave(1);
                        FunctionRoleAttribute expectsdFunctionRoleAttribute = TestUtilities.NewTestFunctionRoleAttribute(1);

                        // Test
                        returnStatus = UserManagement.AddFunctionRoleAttribute(expectedFunctionRole, expectsdFunctionRoleAttribute, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus, "AddFunctionRoleAttribute return status:");

                        FunctionRole checkFunctionRole = UserManagement.FunctionalRoles[expectedFunctionRole.Name];
                        FunctionRoleAttribute checkFunctionRoleAttribute = checkFunctionRole.Attributes[expectsdFunctionRoleAttribute.ToString()];
                        Assert.AreEqual(1, checkFunctionRole.Attributes.Count);
                        Assert.AreEqual(expectsdFunctionRoleAttribute.Category.ID, checkFunctionRoleAttribute.Category.ID);
                        Assert.AreEqual(expectsdFunctionRoleAttribute.Subcategory.ID, checkFunctionRoleAttribute.Subcategory.ID);
                        Assert.AreEqual(expectsdFunctionRoleAttribute.Mask.ID, checkFunctionRoleAttribute.Mask.ID);
                        Assert.AreEqual(expectsdFunctionRoleAttribute.ToString(), checkFunctionRoleAttribute.ToString());

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                [ExpectedException(typeof(System.Collections.Generic.KeyNotFoundException))]
                public void RemoveFunctionRoleAttribute()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";

                        FunctionRole expectedFunctionRole = TestUtilities.NewTestFunctionRoleWithSave(1);
                        FunctionRoleAttribute expectsdFunctionRoleAttribute = TestUtilities.NewTestFunctionRoleAttribute(1);
                        returnStatus = UserManagement.AddFunctionRoleAttribute(expectedFunctionRole, expectsdFunctionRoleAttribute, ref errorMessage);
                        if (!returnStatus)
                                throw new Exception("Add Function Role Attribute Error");
                        FunctionRole checkFunctionRole = UserManagement.FunctionalRoles[expectedFunctionRole.Name];
                        FunctionRoleAttribute checkFunctionRoleAttribute = checkFunctionRole.Attributes[expectsdFunctionRoleAttribute.ToString()];

                        // Test
                        returnStatus = UserManagement.RemoveFunctionRoleAttribute(checkFunctionRole, checkFunctionRoleAttribute, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus, "RemoveFunctionRoleAttribute return status:");

                        try
                        {
                                // Check that FunctionRoleAttribute does not exist in FunctionRoleAttributes dictionary
                                // Expected exception System.Collections.Generic.KeyNotFoundException
                                checkFunctionRole = UserManagement.FunctionalRoles[expectedFunctionRole.Name];
                                checkFunctionRoleAttribute = checkFunctionRole.Attributes[expectsdFunctionRoleAttribute.ToString()];
                        }
                        finally
                        {
                                // Restore to previous state
                                Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                        }
                }
                [Test]
                [ExpectedException(typeof(System.Collections.Generic.KeyNotFoundException))]
                public void RemoveFunctionRole()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        bool returnStatus;
                        string errorMessage = "";

                        FunctionRole expectedFunctionRole = TestUtilities.NewTestFunctionRoleWithSave(1);

                        // Test
                        returnStatus = UserManagement.RemoveFunctionRole(expectedFunctionRole, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnStatus, "RemoveFunctionRole return status:");

                        try
                        {
                                // Check that FunctionRole does not exist in FunctionRoles dictionary
                                // Expected exception System.Collections.Generic.KeyNotFoundException
                                FunctionRole checkFunctionRole = UserManagement.FunctionalRoles[expectedFunctionRole.Name];
                                Assert.AreEqual(expectedFunctionRole.Name, checkFunctionRole.Name);
                        }
                        finally
                        {
                                // Restore to previous state
                                Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                        }
                }
                [Test]
                public void GetDistrictsByRegion()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        int expectedCount = 3;

                        District[] expectedDistricts = new District[expectedCount];
                        Region region = TestUtilities.NewTestRegionWithSave(1);
                        for (int i = 0; i < expectedCount - 1; i++)
                                expectedDistricts[i] = TestUtilities.NewTestDistrictWithSave(i, region);

                        // Test
                        Districts checkDistricts = UserManagement.GetDistrictsByRegion(region);

                        // Checks
                        Assert.AreEqual(expectedCount, checkDistricts.Count, "Wrong Districts count:");

                        for (int i = 0; i < expectedCount - 1; i++)
                                Assert.AreEqual(expectedDistricts[i].Name, checkDistricts[expectedDistricts[i].Name].Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void GetFacilitiesByRegionAndDistrict()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        int expectedCount = 4;

                        Facility[] expectedFacilities = new Facility[expectedCount];
                        Region region = TestUtilities.NewTestRegionWithSave(1);
                        District district = TestUtilities.NewTestDistrictWithSave(1, region);
                        for (int i = 0; i < expectedCount - 1; i++)
                        {
                                expectedFacilities[i] = TestUtilities.NewTestFacilityWithSave(i, region, district);
                        }

                        // Test
                        Facilities checkFacilities = UserManagement.GetFacilitiesByRegionAndDistrict(region, district);

                        // Checks
                        Assert.AreEqual(expectedCount, checkFacilities.Count, "Wrong Facilities count:");

                        for (int i = 0; i < expectedCount - 1; i++)
                                Assert.AreEqual(expectedFacilities[i].Name, checkFacilities[expectedFacilities[i].Name].Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void GetFunctionalRoleSubcategories()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        int expectedCount = 4;

                        FunctionRole.Subcategory[] expectedSubcategories = new FunctionRole.Subcategory[expectedCount];
                        FunctionRole.Category category = TestUtilities.NewTestCategoryWithSave(1);
                        for (int i = 0; i < expectedCount - 1; i++)
                                expectedSubcategories[i] = TestUtilities.NewTestSubcategoryWithSave(i, category);

                        // Test
                        FunctionRoleSubcategories checkSubcategories = UserManagement.GetFunctionalRoleSubcategories(category);

                        // Checks
                        Assert.AreEqual(expectedCount, checkSubcategories.Count, "Wrong Subcategories count:");

                        for (int i = 0; i < expectedCount - 1; i++)
                                Assert.AreEqual(expectedSubcategories[i].Name, checkSubcategories[expectedSubcategories[i].Name].Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                [Test]
                public void GetMasks()
                {
                        // Clear DB
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB before test error");

                        // Preparations
                        int expectedCount = 3;

                        Mask[] expectedMasks = new Mask[expectedCount];
                        FunctionRole.Category category = TestUtilities.NewTestCategoryWithSave(1);
                        FunctionRole.Subcategory subcategory = TestUtilities.NewTestSubcategoryWithSave(1, category);
                        for (int i = 0; i < expectedCount - 1; i++)
                                expectedMasks[i] = TestUtilities.NewTestMaskWithSave(i, category, subcategory);

                        // Test
                        Masks checkMasks = UserManagement.GetMasks(category, subcategory);

                        // Checks
                        Assert.AreEqual(expectedCount, checkMasks.Count, "Wrong Masks count:");

                        for (int i = 0; i < expectedCount - 1; i++)
                                Assert.AreEqual(expectedMasks[i].Name, checkMasks[expectedMasks[i].Name].Name);

                        // Restore to previous state
                        Assert.IsTrue(TestUtilities.TruncateTables(), "Clear DB after test error");
                }
                #endregion

                #region Private Utilities
                #endregion
        }
}